﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using Studio7i.Dominio;
using Studio7i.Persistencia;

namespace Studio7i.Pruebas
{
    public class TestClienteDAO
    {

        [TestFixture]
        public class Test1_clienteDAO
        {
            // Atributos a utilizar durante las pruebas
            private ClienteDAO clienteDAO = null;
            private int codigoGenerado = 0;

            [TestFixtureSetUp]
            public void PrepararPruebas()
            {
                // 1. Definimos la implementación del DAO a probar (ADO / NH / EF)
                clienteDAO = new Persistencia.ClienteDAO();

                // 2. Eliminamos todos los cientes en BD antes de las pruebas
                foreach (Cliente cliente in clienteDAO.ListarTodos())
                    clienteDAO.Eliminar(cliente);

                // 3. Creamos 3 clientes para tenerlos disponibles en las pruebas
                clienteDAO.Crear(new Cliente(1, "Diana", "1234", "41763158", "Diana", "Deza", "ddezag@gmail.com", DateTime.ParseExact("01-01-2009", "dd-MM-yyyy", null)));
                clienteDAO.Crear(new Cliente() { CodUser = 2, NombreUsuario = "Bruce", Clave = "5678", DNI = "12345678", Nombres = "Bruce", Apellidos = "Polo Zambrano", Email = "bruce@gmail.com", FechaNac = DateTime.ParseExact("02-03-1983", "dd-MM-yyyy", null) });
                clienteDAO.Crear(new Cliente() { CodUser = 3, NombreUsuario = "Diana", Clave = "1111", DNI = "87654321", Nombres = "Cesar", Apellidos = "Deza", Email = "cesar@gmail.com", FechaNac = DateTime.ParseExact("01-12-1988", "dd-MM-yyyy", null) });

            }
            [Test]
            public void Test1_Crear()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);

                // 2. Declaramos e instanciamos la entidad de dominio
                Cliente clienteACrear = new Cliente();
                clienteACrear.CodUser = 3;
                clienteACrear.NombreUsuario = "ktervas";
                clienteACrear.Clave = "1111";
                clienteACrear.DNI = "41234569";
                clienteACrear.Nombres = "Cesar";
                clienteACrear.Apellidos = "Deza Gabriel";
                clienteACrear.Email = "ktervas@hotmail.com";
                clienteACrear.FechaNac = DateTime.ParseExact("02-08-1986", "dd-MM-yyyy", null);

                // 3. Declaramos la entidad que contendrá el resultado
                Cliente clienteCreado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clienteCreado = clienteDAO.Crear(clienteACrear);
                    codigoGenerado = clienteCreado.CodUser;
                }, "cliente creado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clienteCreado);
                // Probamos que el código generado sea mayor a 0
                Assert.Greater(clienteCreado.CodUser, 0);
                // Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(clienteCreado.NombreUsuario, clienteACrear.NombreUsuario);

            }

            [Test]
            public void Test2_Obtener()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);
                // 2. Definimos los datos para la prueba
                int codigo = 1;
                // 3. Declaramos la entidad que contendrá el resultado
                Cliente clienteObtenido = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clienteObtenido = clienteDAO.Obtener(codigo);
                });

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clienteObtenido);
                Assert.AreEqual(clienteObtenido.CodUser, codigo);
                Assert.IsNotNullOrEmpty(clienteObtenido.NombreUsuario);
                Assert.IsNotNullOrEmpty(clienteObtenido.DNI);

            }

            [Test]
            public void Test3_Modificar()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a modificar
                Cliente clienteAModificar = new Cliente();
                clienteAModificar.CodUser = 1;
                clienteAModificar.NombreUsuario = "ktervitas";
                clienteAModificar.Clave = "2222";
                clienteAModificar.DNI = "41234569";
                clienteAModificar.Nombres = "Cesar";
                clienteAModificar.Apellidos = "Deza Gabriel";
                clienteAModificar.Email = "ktervas@hotmail.com";
                clienteAModificar.FechaNac = DateTime.ParseExact("07-07-1987", "dd-MM-yyyy", null);

                // 3. Declaramos la entidad que contendrá el resultado
                Cliente clienteModificado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clienteModificado = clienteDAO.Modificar(clienteAModificar);
                }, "cliente modificado");
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clienteModificado);
                // Probamos que el código generado sea mayor a 0
                Assert.AreEqual(clienteModificado.CodUser, 1);
                // Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(clienteModificado.NombreUsuario, clienteAModificar.NombreUsuario);

            }

            [Test]
            public void Test4_Eliminar()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a eliminar
                codigoGenerado = 3;
                Cliente clienteAEliminar = clienteDAO.Obtener(codigoGenerado);

                // 3. Declaramos la entidad que contendrá el resultado
                Cliente clienteEliminado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clienteDAO.Eliminar(clienteAEliminar);
                }, "cliente eliminado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNull(clienteEliminado);

            }
            [Test]
            public void Test5_ListarTodos()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);
                // 2. Declaramos la entidad que contendrá el resultado
                ICollection<Cliente> clientesEncontrados = null;
                // 3. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clientesEncontrados = clienteDAO.ListarTodos();
                }, "Clientes Listados");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clientesEncontrados);

                // Probamos que la cantidad de instrumentos encontrados sea 1
                // Assert.AreEqual(clientesEncontrados.Count, 1);

                // Probamos que cada instrumento contenga la cadena de búsqueda en su nombre
                foreach (Cliente clienteEncontrado in clientesEncontrados)
                {
                    Assert.IsNotNull(clienteEncontrado);
                    Assert.IsInstanceOf(typeof(Cliente), clienteEncontrado);
                }
            }

            [Test]
            public void Test6_ListarXNombre()
            {
                // 1. Clase a probar: ClienteDAO
                Assert.IsNotNull(clienteDAO);

                // 2. Definimos los datos para la prueba
                string busqueda = "Cesar"; // 

                // 3. Declaramos la entidad que contendrá el resultado
                ICollection<Cliente> clientesEncontrados = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    clientesEncontrados = clienteDAO.ListarXNombre(busqueda);
                });

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clientesEncontrados);

                // Probamos que la cantidad de clientes encontrados no sea 0
                Assert.AreNotEqual(clientesEncontrados.Count, 0);

                // Probamos que cada cliente contenga la cadena de búsqueda en su nombre
                foreach (Cliente clienteEncontrado in clientesEncontrados)
                {
                    Assert.IsTrue(clienteEncontrado.Nombres.Contains(busqueda));
                }
            }

            [Test]
            public void Test7_ListarXBusqueda()
            {
                // 1. Clase a probar: clienteDAO
                Assert.IsNotNull(clienteDAO);

                // 2. Definimos los datos para la prueba
                // string nombre = "Ces"; // Rock *
                string apellidos = "Deza Gabriel";

                // 3. Declaramos la entidad que contendrá el resultado
                ICollection<Cliente> clientesEncontrados = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    //clientesEncontrados = clienteDAO.ListarXBusqueda(null, nombre, null, null, null);
                    clientesEncontrados = clienteDAO.ListarXBusqueda(null, null, null, null, apellidos,null);
                });
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(clientesEncontrados);

                // Probamos que la cantidad de clientes encontrados sea 2
                Assert.AreEqual(clientesEncontrados.Count, 2);

                // Probamos que cada cliente contenga la cadena de búsqueda en su nombre
                foreach (Cliente clienteEncontrado in clientesEncontrados)
                {
                    Assert.IsTrue(clienteEncontrado.Apellidos.Contains(apellidos));
                }
            }

        }
    }
}